/**
 * Moonshot AI 服务集成
 * API文档: https://platform.moonshot.cn/docs/api-reference
 */

class MoonshotService {
  constructor() {
    this.baseURL = 'https://api.moonshot.cn/v1'
    this.apiKey = 'sk-9m78YQZh9aH9J08xL3mEvvHZEJy8q0Zo0Ds75SZTdihRvnnz'
    this.timeout = 60000
    this.retryCount = 3
  }

  /**
   * 获取请求头
   * @private
   */
  getHeaders() {
    return {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${this.apiKey}`
    }
  }

  /**
   * 基础HTTP请求方法
   * @private
   */
  async request(endpoint, data = null, method = 'POST') {
    const url = `${this.baseURL}${endpoint}`
    
    const options = {
      method,
      headers: this.getHeaders(),
      signal: AbortSignal.timeout(this.timeout)
    }

    if (data && method !== 'GET') {
      options.body = JSON.stringify(data)
    }

    let lastError
    
    // 重试机制
    for (let i = 0; i < this.retryCount; i++) {
      try {
        const response = await fetch(url, options)
        
        if (!response.ok) {
          const errorData = await response.json().catch(() => ({}))
          throw new Error(`HTTP ${response.status}: ${errorData.error?.message || response.statusText}`)
        }
        
        return await response.json()
        
      } catch (error) {
        lastError = error
        
        // 如果是最后一次重试或者是客户端错误，直接抛出
        if (i === this.retryCount - 1 || error.message.includes('4')) {
          break
        }
        
        // 等待后重试
        await this.delay(1000 * (i + 1))
      }
    }
    
    throw lastError
  }

  /**
   * 延迟函数
   * @private
   */
  delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms))
  }

  /**
   * 获取可用模型列表
   */
  async getModels() {
    try {
      const response = await this.request('/models', null, 'GET')
      return {
        status: true,
        data: response.data || []
      }
    } catch (error) {
      console.error('获取模型列表失败:', error)
      // 返回默认的Moonshot模型
      return {
        status: true,
        data: [
          {
            id: 'moonshot-v1-8k',
            object: 'model',
            created: Date.now(),
            owned_by: 'moonshot',
            name: 'Moonshot v1 8K',
            description: '月之暗面8K上下文模型'
          },
          {
            id: 'moonshot-v1-32k',
            object: 'model',
            created: Date.now(),
            owned_by: 'moonshot',
            name: 'Moonshot v1 32K',
            description: '月之暗面32K上下文模型'
          },
          {
            id: 'moonshot-v1-128k',
            object: 'model',
            created: Date.now(),
            owned_by: 'moonshot',
            name: 'Moonshot v1 128K',
            description: '月之暗面128K上下文模型'
          }
        ]
      }
    }
  }

  /**
   * 聊天对话
   * @param {Object} params - 聊天参数
   * @param {string} params.message - 用户消息
   * @param {Array} params.history - 历史对话
   * @param {string} params.model - 模型名称
   * @param {Object} params.config - 配置参数
   */
  async chat(params) {
    const {
      message,
      history = [],
      model = 'moonshot-v1-8k',
      config = {}
    } = params

    if (!message || !message.trim()) {
      throw new Error('消息内容不能为空')
    }

    // 构建消息历史
    const messages = [
      ...history,
      { role: 'user', content: message }
    ]

    try {
      const response = await this.request('/chat/completions', {
        model,
        messages,
        temperature: config.temperature || 0.3,
        max_tokens: config.max_tokens || 2000,
        top_p: config.top_p || 1,
        stream: false
      })

      return {
        status: true,
        data: {
          content: response.choices[0].message.content,
          usage: response.usage,
          model: response.model
        }
      }
    } catch (error) {
      console.error('Moonshot聊天失败:', error)
      throw new Error(`聊天失败: ${error.message}`)
    }
  }

  /**
   * 流式聊天对话
   * @param {Object} params - 聊天参数
   * @param {Function} onMessage - 接收消息回调
   * @param {Function} onComplete - 完成回调
   * @param {Function} onError - 错误回调
   */
  async chatStream(params, onMessage, onComplete, onError) {
    const {
      message,
      history = [],
      model = 'moonshot-v1-8k',
      config = {}
    } = params

    if (!message || !message.trim()) {
      onError?.(new Error('消息内容不能为空'))
      return
    }

    // 构建消息历史
    const messages = [
      ...history,
      { role: 'user', content: message }
    ]

    try {
      const response = await fetch(`${this.baseURL}/chat/completions`, {
        method: 'POST',
        headers: this.getHeaders(),
        body: JSON.stringify({
          model,
          messages,
          temperature: config.temperature || 0.3,
          max_tokens: config.max_tokens || 2000,
          top_p: config.top_p || 1,
          stream: true
        })
      })

      if (!response.ok) {
        const errorData = await response.json().catch(() => ({}))
        throw new Error(`HTTP ${response.status}: ${errorData.error?.message || response.statusText}`)
      }

      const reader = response.body.getReader()
      const decoder = new TextDecoder()

      while (true) {
        const { done, value } = await reader.read()
        
        if (done) {
          onComplete?.()
          break
        }

        const chunk = decoder.decode(value, { stream: true })
        const lines = chunk.split('\n')
        
        for (const line of lines) {
          if (line.startsWith('data: ')) {
            const data = line.slice(6).trim()
            
            if (data === '[DONE]') {
              onComplete?.()
              return
            }
            
            try {
              const parsed = JSON.parse(data)
              const content = parsed.choices?.[0]?.delta?.content
              
              if (content) {
                onMessage?.(content)
              }
            } catch (e) {
              // 忽略解析错误，继续处理下一行
            }
          }
        }
      }
    } catch (error) {
      console.error('Moonshot流式聊天失败:', error)
      onError?.(error)
    }
  }

  /**
   * 代码生成
   * @param {string} requirement - 需求描述
   * @param {string} language - 编程语言
   * @param {string} model - 使用的模型
   */
  async generateCode(requirement, language = 'javascript', model = 'moonshot-v1-8k') {
    const prompt = `请用${language}语言编写代码来实现以下需求：

需求描述：${requirement}

要求：
1. 代码要简洁、高效、易读
2. 包含必要的注释
3. 遵循最佳实践
4. 只返回代码，不需要额外说明

请开始编写代码：`

    return await this.chat({
      message: prompt,
      model,
      config: {
        temperature: 0.2, // 代码生成使用较低温度
        max_tokens: 2000
      }
    })
  }

  /**
   * 文本翻译
   * @param {string} text - 待翻译文本
   * @param {string} targetLang - 目标语言
   * @param {string} model - 使用的模型
   */
  async translate(text, targetLang = '英文', model = 'moonshot-v1-8k') {
    const prompt = `请将以下文本翻译成${targetLang}，要求翻译准确、自然、符合目标语言的表达习惯：

原文：${text}

译文：`

    return await this.chat({
      message: prompt,
      model,
      config: {
        temperature: 0.3,
        max_tokens: 1000
      }
    })
  }

  /**
   * 文本总结
   * @param {string} text - 待总结文本
   * @param {string} model - 使用的模型
   */
  async summarize(text, model = 'moonshot-v1-8k') {
    const prompt = `请对以下文本进行总结，要求：
1. 提取主要观点和关键信息
2. 保持逻辑清晰、条理分明
3. 长度适中，简洁明了

原文：
${text}

总结：`

    return await this.chat({
      message: prompt,
      model,
      config: {
        temperature: 0.3,
        max_tokens: 800
      }
    })
  }

  /**
   * 文本润色
   * @param {string} text - 待润色文本
   * @param {string} style - 润色风格
   * @param {string} model - 使用的模型
   */
  async polish(text, style = '专业', model = 'moonshot-v1-8k') {
    const prompt = `请对以下文本进行润色，要求：
1. 风格：${style}
2. 语言流畅、表达准确
3. 保持原意不变
4. 提升可读性和专业性

原文：
${text}

润色后：`

    return await this.chat({
      message: prompt,
      model,
      config: {
        temperature: 0.4,
        max_tokens: 1200
      }
    })
  }

  /**
   * 文档分析
   * @param {string} document - 文档内容
   * @param {string} question - 分析问题
   * @param {string} model - 使用的模型
   */
  async analyzeDocument(document, question, model = 'moonshot-v1-32k') {
    const prompt = `请基于以下文档内容回答问题：

文档内容：
${document}

问题：${question}

请提供详细、准确的分析和回答：`

    return await this.chat({
      message: prompt,
      model,
      config: {
        temperature: 0.3,
        max_tokens: 2000
      }
    })
  }

  /**
   * 创意写作
   * @param {string} topic - 写作主题
   * @param {string} type - 写作类型
   * @param {string} model - 使用的模型
   */
  async creativeWriting(topic, type = '文章', model = 'moonshot-v1-8k') {
    const prompt = `请以"${topic}"为主题，写一篇${type}。要求：
1. 内容原创、有创意
2. 结构清晰、逻辑合理
3. 语言生动、引人入胜
4. 长度适中

请开始创作：`

    return await this.chat({
      message: prompt,
      model,
      config: {
        temperature: 0.7,
        max_tokens: 2000
      }
    })
  }

  /**
   * 错误处理
   * @param {Error} error - 错误对象
   * @returns {string} 用户友好的错误消息
   */
  static handleError(error) {
    console.error('Moonshot AI服务错误:', error)
    
    if (error.message.includes('401')) {
      return 'API密钥无效，请检查配置'
    } else if (error.message.includes('429')) {
      return '请求过于频繁，请稍后再试'
    } else if (error.message.includes('timeout')) {
      return '请求超时，请检查网络连接'
    } else if (error.message.includes('500')) {
      return 'Moonshot服务内部错误，请稍后重试'
    } else {
      return 'Moonshot AI服务暂时不可用，请稍后重试'
    }
  }
}

// 创建单例实例
const moonshotService = new MoonshotService()

export default moonshotService
export { MoonshotService }
